home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / 2DLab / TwoDView.m < prev    next >
Encoding:
Text File  |  1992-01-14  |  31.3 KB  |  1,235 lines
  1. /* Generated by Interface Builder */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h> /* qsort blah blah */
  5.  
  6. #import "TwoDView.h"
  7. #import "TwoDTSP.h"
  8. #import <math.h>
  9. #import <appkit/appkit.h>
  10. #import <appkit/Matrix.h>
  11. #import <appkit/Form.h>
  12. #import <appkit/nextstd.h>
  13. #import <dpsclient/wraps.h>
  14.  
  15. #define NI PSnewinstance()
  16.  
  17. #ifdef DEBUG /* put this in so the console sould not get flooded. */
  18. // #define PRINTLOTS
  19. #endif
  20. #define MESSAGE(x) printf("%s\n",x)
  21. @implementation TwoDView
  22.  
  23. /* Map the square [-1 .. 1]x[-1 .. 1] to the TwoDView, leaving a margin
  24.  * of 10%, and centering the origin.
  25.  *
  26.  * the View must already be lockFocused.
  27.  */
  28. void setUpScaling(TwoDView *self)
  29. {
  30.   NXRect r;
  31.   [self getBounds:&r];
  32.   PStranslate(r.size.width/2,r.size.height/2);
  33.   PSscale(0.9*0.5*r.size.width,0.9*0.5*r.size.height);
  34. }
  35.  
  36. /*
  37.  * set the drawing attributes (except for instance mode flag).
  38.  * 
  39.  * The code for setting line width averages the two sides of the
  40.  * bounds rectangle, to avoid really nasty-looking lines when the view's
  41.  * aspect ratio is not close to unity.  There are probably better ways
  42.  * to do this.
  43.  *
  44.  * the View must already be lockFocused.
  45.  */
  46. void setUpDrawing(TwoDView *self)
  47. {
  48.   NXRect r;
  49.   [self getBounds:&r];
  50.   self->width=([self->lineWidthSlider floatValue]*2.0)/
  51.               (r.size.width+r.size.height);
  52.   if (self->width)
  53.     PSsetlinewidth(self->width);
  54.   else {
  55.     if (NXDrawingStatus == NX_PRINTING) PSsetlinewidth(0.001);
  56.     else PSsetlinewidth(0.0);
  57.     };
  58. }
  59.  
  60. /*
  61.  * initialize instance variables relating to the data structures.
  62.  * This is broken out of
  63.  * the newFrame: method because mouseDown: events and open: will
  64.  * also need to initialize those quantities.
  65.  *
  66.  * the instance variable numPoints contains the old value that
  67.  * we will be replacing.
  68.  *
  69.  * cases: numPoints=npoints : no alloc, but clear flags.
  70.  *        numPoints=0, npoints > 0 : alloc arrays, etc.
  71.  *        numPoints>0, npoints = 0 : clobber arrays, etc.
  72.  *        numPoints>0, npoints > 0 : realloc arrays, etc.
  73.  *     
  74.  * this function does NOT put any data in the array.  The caller must
  75.  * do that.
  76.  *
  77.  * storage is not allocated for the Delaunay, Gabriel and relative neighborhood
  78.  * graphs because they could be completely connected (large!) but usually
  79.  * aren't.  They will be allocated in the appropriate doFooGraph routines
  80.  * (below).
  81.  */
  82. void initGeometryStuff(TwoDView *self,int npoints)
  83. {
  84. #ifdef DEBUG
  85.     MESSAGE("initGeometryStuff");
  86. #endif
  87.  
  88.   if (self->numPoints == npoints) {
  89.     self->mstExists=self->chExists=self->vorExists=
  90.                     self->ggExists=self->rngExists=self->dtExists=NO;
  91.     return;
  92.     };
  93.   if (!self->numPoints) { /* alloc */
  94.     NX_MALLOC(self->data,float,npoints*2);
  95.     NX_MALLOC(self->mst_edge,int,(npoints-1)*2);
  96.     NX_MALLOC(self->ch_vertex,int,npoints);
  97.     NX_MALLOC(self->tsp_edges,int,npoints*2);
  98.     }
  99.   else {
  100.     if (!npoints) { /* clobber */
  101.       NX_FREE(self->data);
  102.       NX_FREE(self->mst_edge);
  103.       NX_FREE(self->ch_vertex);
  104.       NX_FREE(self->tsp_edges);
  105.       }
  106.     else {
  107.       NX_REALLOC(self->data,float,npoints*2);
  108.       NX_REALLOC(self->mst_edge,int,(npoints-1)*2);
  109.       NX_REALLOC(self->tsp_edges,int,npoints*2);
  110.       };
  111.     };
  112.   self->numPoints=npoints;
  113.   [self->numPointsForm setIntValue:self->numPoints at:0];
  114.   self->mstExists=self->chExists=self->vorExists=
  115.                   self->ggExists=self->rngExists=self->dtExists=NO;
  116. }
  117.  
  118. /*
  119.  * make some text appear in the `Status' box
  120.  */
  121. #define STATUS(s) [statusText setStringValue:s]
  122.  
  123. /*
  124.  * set things up.
  125.  */
  126. + newFrame:(NXRect *)frameRect
  127. {
  128.   self = [[super newFrame:frameRect] allocateGState]; /* lots of focus pocus */
  129.   numPoints=0; /* this will be fixed */
  130.   operation=OP_PRIM_MST; /* agree with .nib */
  131.   autoUpdate=1; /* agree with .nib */
  132.   srandom(time(0));
  133.   [self random:0];
  134.   displayFlag = DISP_PTS_RESULTS;
  135.   return self;
  136. }
  137.  
  138. /* create a list of 2D points to demonstrate the algms on.
  139.  * if sender is nil (zero), random: was called from initFrame. Otherwise,
  140.  * the Generate button was pressed.
  141.  */
  142.  
  143. - random:sender
  144. {
  145.   int i,n;
  146.  
  147.   if (sender && numPointsForm)
  148.     n = [numPointsForm intValueAt:0];
  149.   else
  150.     n = 10; /* must be initializing */
  151.  
  152.   initGeometryStuff(self,n);  /* numPOints gets set */
  153.  
  154.   for(i=0;i<numPoints;i++) {
  155.     X(i)=2.0*(random()&65535)/65536.0 - 1.0;
  156.     Y(i)=2.0*(random()&65535)/65536.0 - 1.0;
  157.     };
  158.  
  159.   if (sender) {
  160.     if (autoUpdate) [self animThenDisp:0];
  161.     else [self disp:0];
  162.     };
  163.   return self;
  164. }
  165.  
  166. - mouseDown:(NXEvent *)theEvent
  167. {
  168.   NXPoint where = theEvent->location;
  169.   NXRect r;
  170.   float x,y,cx,cy;
  171.   [self convertPoint:&where fromView:nil];
  172.   [self getBounds:&r];
  173.   cx=r.origin.x+0.5*r.size.width;
  174.   cy=r.origin.y+0.5*r.size.height;
  175.  
  176.   x=(where.x - cx)/(0.5*0.9*r.size.width)+0.001;
  177.   y=(where.y - cy)/(0.5*0.9*r.size.height)+0.001;
  178.   if ((fabs(x) > 1.0)||(fabs(y) > 1.0)) return self;
  179. #ifdef DEBUG
  180.   fprintf(stderr,"x %f y %f\n",x,y);
  181. #endif
  182.  
  183.   initGeometryStuff(self,numPoints+1); /* numPoints gets reset */
  184.   X(numPoints-1)=x;
  185.   Y(numPoints-1)=y;
  186.  
  187.   if (autoUpdate) [self animThenDisp:0];
  188.   else [self disp:0];
  189.   return self;
  190. }
  191.  
  192. - free
  193. { initGeometryStuff(self,0); [super free]; return self; }
  194. /*--------------------------------------------------------------------
  195. Enable the form cell if it han an optimal value.
  196. Assume that the cell is disabled.
  197.                                                  Bill Roth/1991-Nov-26
  198. --------------------------------------------------------------------*/
  199.  
  200. - setOperation:(Matrix *)sender
  201. { 
  202.     operation=[sender selectedRow]; 
  203.     if (operation >= OP_TSP_STUPID_NEIGHBOR) {
  204.     [optimalValueFormCell setEnabled: YES];
  205.     [timeSlider setEnabled: YES];
  206.     [timeField setEnabled: YES];
  207.     }
  208.     else {
  209.     [optimalValueFormCell setEnabled: NO];
  210.     [timeSlider setEnabled: NO];
  211.     [timeField setEnabled: NO];
  212.     [optimizeButton setEnabled: NO];
  213.     }
  214.     return self; 
  215. }
  216.  
  217. - setAutoUpdate:(Button *)sender
  218. { autoUpdate = [sender state]; return self; }
  219.  
  220.  
  221. /* This method is invoked when the user bangs on the Animate/Display button. */
  222. /*--------------------------------------------------------------------
  223. Sets the display-pts-only flad, the calls [display] to draw points.
  224. Then does the appropriate drawing routine, then when finished, calls 
  225. [disp] which will call display and tell it do display everything.
  226.  
  227.                                                  Bill Roth/1991-Nov-17
  228. --------------------------------------------------------------------*/
  229.  
  230. - animThenDisp:sender
  231. {
  232. #ifdef DEBUG
  233.     MESSAGE("animthenDisp");
  234. #endif
  235.  
  236.   /* erase prior drawing and display points only */
  237.   displayFlag = DISP_PTS_ONLY;
  238.   [self display];
  239.  
  240.   /* get ready to draw (in instance mode) */
  241.   [self lockFocus];
  242.   setUpScaling(self);
  243.   NXSetColor([self->highColorWell color]);
  244.   setUpDrawing(self);
  245.   PSsetinstance(YES);
  246.  
  247.   /* do the operation (drawing in the doFoo methods is all instance drawing) */
  248.   switch(operation) {
  249.     case OP_PRIM_MST: [self doPrimMST]; break;
  250.     case OP_KRUSKAL_MST: [self doKruskalMST]; break;
  251.     case OP_JARVIS_HULL: [self doJarvisHull]; break;
  252.     case OP_GRAHAM_HULL: [self doGrahamHull]; break;
  253.     case OP_VORONOI_DIAGRAM: [self doVoronoiDiagram]; break;
  254.     case OP_DELAUNAY_TRIANGULATION: [self doDelaunayTriangulation]; break;
  255.     case OP_GABRIEL_GRAPH: [self doGabrielGraph]; break;
  256.     case OP_RELATIVE_NEIGHBORHOOD_GRAPH: [self doRelativeNeighborhoodGraph];
  257.                                          break;
  258.     case OP_TSP_STUPID_NEIGHBOR:
  259.             [self doSimpleNearNeighbor]; break;
  260.     case OP_TSP_CHEAPEST_INSERTION: [self doCheapestInsertion]; break;
  261.     case OP_TSP_NEAREST_NEIGHBOR: [self doNearestNeighbor]; break;
  262.     case OP_TSP_NEAREST_ADDITION: [self doNearestAddition]; break;
  263.     case OP_TSP_FARTHEST_INSERTION: [self doFarthestInsertion]; break;
  264.     }
  265.  
  266.   /* clear instance mode drawing  and reset things*/
  267.   PSsetinstance(NO);
  268.   [self unlockFocus];
  269.  
  270.   /* display results */
  271.   displayFlag = DISP_PTS_RESULTS;
  272.   [self disp:0];
  273.   return self;
  274. }
  275.  
  276. -disp:sender
  277. {
  278.   [self display];
  279.   return self;
  280. }
  281.  
  282.  
  283. /* Kruskal's MST algorithm (non-optimal quadratic version) */
  284.  
  285. static float *length;
  286.  
  287. int ycompar(p1,p2)
  288.   int *p1,*p2;
  289.   {
  290.     float l1=length[*p1],l2=length[*p2];
  291.     if (l1<l2) return -1;
  292.     if (l1>l2) return 1;
  293.     return 0;
  294.   }
  295.  
  296. float cost(float *p1,float *p2) /* squd Eucl distance between 2 2D points */
  297. {
  298.   float x1,x2,y1,y2;
  299.   x1= p1[0]; y1=p1[1];
  300.   x2= p2[0]; y2=p2[1];
  301.   return((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
  302. }
  303.  
  304. /*
  305.   XXX
  306.        THIS IMPLEMENTATION IS NOT OPTIMAL
  307.   XXX
  308. */
  309.  
  310. - doKruskalMST
  311. {
  312.   int *group,groupindex=1;
  313.   int *edge,*edgptr,*index,idx;
  314.   int i;
  315.   float *lptr;
  316. #ifdef DEBUG
  317.     MESSAGE("doKruskalMST");
  318. #endif
  319.  
  320.   STATUS("sorting edges by length");
  321.   NX_MALLOC(edge,int,numPoints*(numPoints-1));
  322.   edgptr=edge;
  323.   NX_MALLOC(length,float,numPoints*(numPoints-1)/2);
  324.   lptr=length;
  325.   /* fill in edge endpoint and length arrays */
  326.   for(i=0;i<numPoints-1;i++) {
  327.     int j;
  328.     char buf[80];
  329.     sprintf(buf,"point %d",i);
  330.     STATUS(buf);
  331.     for(j=i+1;j<numPoints;j++) {
  332.       *edgptr++ = i;
  333.       *edgptr++ = j;
  334.       *lptr++ = cost(XY(i),XY(j));
  335.       };
  336.     };
  337.   STATUS("qsorting");
  338.   NX_MALLOC(index,int,numPoints*(numPoints-1)/2);
  339.   for(i=0;i<numPoints*(numPoints-1)/2;i++) index[i]=i;
  340.   /* sort edges */
  341.   qsort(index,numPoints*(numPoints-1)/2,sizeof(int),ycompar);
  342.  
  343.   NX_MALLOC(group,int,numPoints);
  344.   bzero(group,numPoints*sizeof(int));
  345.   
  346.   /* Algorithm:
  347.      FOR i = 1 to n-1 
  348.        Add (to the tree) the shortest edge that does not form a circuit in
  349.        the tree.
  350.      ROF
  351.   */
  352.   idx=0;
  353.   for(i=0;i<numPoints-1;i++) {
  354.     char flag=FALSE;
  355.     char buf[80];
  356.     sprintf(buf,"adding edge %d",i);
  357.     STATUS(buf);
  358.     while (!flag) { /* look for an edge */
  359.       int j;
  360.       int v1=edge[index[idx]*2],g1=group[v1];
  361.       int v2=edge[index[idx++]*2+1],g2=group[v2];
  362.       NI;
  363.       [self drawEdge:X(v1):Y(v1):X(v2):Y(v2)];
  364.       NXPing();
  365.       if ((!g1&&!g2)||(g1!=g2)) {
  366.         flag=TRUE;
  367.         mst_edge[i*2]=v1;
  368.         mst_edge[i*2+1]=v2;
  369.         if (g1&&!g2) group[v2]=g1;
  370.         else if(g2&&!g1) group[v1]=g2;
  371.         else if (!g1 && !g2) group[v1]=group[v2]=groupindex++;
  372.         else  /* relabel all g2's to g1 */
  373.           for(j=0;j<numPoints;j++) if (group[j]==g2) group[j]=g1;
  374.         };
  375.       };
  376.     };
  377.   NX_FREE(group);
  378.   NX_FREE(index);
  379.   NX_FREE(length);
  380.   NX_FREE(edge);
  381.   mstExists=YES;
  382.   STATUS("idle");
  383.   return self;
  384. }
  385.  
  386.  
  387. #define SIGNEDAREA(x1,y1,x2,y2,x3,y3) (x1*y2+x3*y1+x2*y3-x3*y2-x1*y3-x2*y1)
  388.  
  389. - doJarvisHull
  390. {
  391. /* Jarvis' march for planar convex hull - From Preparata and Shamos */
  392.   float ymax= -3.0e30,ymin=3.0e30,y,best_x,best_y,candidate_x,candidate_y;
  393.   float current_x,current_y,a;
  394.   int i;
  395.   int nh;
  396.   int current_index=0,best_index=0;
  397.   int min_index=0,max_index=0;
  398.   char *used;
  399.   /* 0. set up storage for indices */
  400. #ifdef DEBUG
  401.     MESSAGE("doJarvisHull");
  402. #endif
  403.  
  404.   NX_MALLOC(used,char,numPoints);
  405.   /* 1. find min & max in y-coordinate */
  406.   STATUS("finding Ymin vertex");
  407.   for(i=0;i<numPoints;i++) {
  408.     y= Y(i);
  409.     if (y<ymin) { ymin=y; min_index=i; };
  410.     if (y>ymax) { ymax=y; max_index=i; };
  411.     };
  412.   nh = 1;
  413.  
  414.   ch_vertex[0]=min_index; /* first hull vertex */
  415.  
  416.   current_index=min_index;
  417.   for(i=0;i<numPoints;i++) used[i]=FALSE;
  418.   /* 2. Jarvis' march - min to max */ 
  419.   STATUS("Jarvis' march: min to max");
  420.   while (current_index!=max_index) {
  421.     used[current_index]=TRUE;
  422.     current_x= X(current_index);
  423.     current_y= Y(current_index);
  424.     best_x= current_x;
  425.     best_y= current_y;
  426.     for(i=0;i<numPoints;i++) if (!used[i]) {
  427.       candidate_x= X(i);
  428.       candidate_y= Y(i);
  429.       NI;
  430.       [self drawEdge:X(current_index):Y(current_index):X(i):Y(i)];
  431.       NXPing();
  432.       a=SIGNEDAREA(current_x,current_y,candidate_x,candidate_y, best_x,best_y);
  433.       if (a>=0.0)
  434.         { best_index=i; best_x=candidate_x; best_y=candidate_y;};
  435.       };
  436.     ch_vertex[nh++] = current_index = best_index;
  437.     };
  438.   /* 3. Jarvis' march - max to min */
  439.   used[min_index]=FALSE;
  440.   STATUS("Jarvis' march: max to min");
  441.   while (current_index!=min_index) {
  442.     used[current_index]=TRUE;
  443.     current_x= X(current_index);
  444.     current_y= Y(current_index);
  445.     best_x=current_x;
  446.     best_y=current_y;
  447.     for(i=0;i<numPoints;i++)  if (!used[i]) {
  448.       candidate_x= X(i);
  449.       candidate_y= Y(i);
  450.       NI;
  451.       [self drawEdge:X(current_index):Y(current_index):candidate_x:candidate_y];
  452.       NXPing();
  453.       a=SIGNEDAREA(current_x,current_y,candidate_x,candidate_y, best_x,best_y);
  454.       if (a>=0.0)
  455.         { best_index=i; best_x=candidate_x; best_y=candidate_y;};
  456.       };
  457.     ch_vertex[nh++] = current_index = best_index;
  458.     };
  459.   nch_vertices=nh;
  460.   NX_FREE(used);
  461.   chExists=YES;
  462.   STATUS("idle");
  463.   return self;
  464. }
  465.  
  466. /* Graham-hull utils */
  467.  
  468. #define QUAD(x,y) ((x<0) ? ((y<0)?3:2) : ((y<0)?4:1))
  469.  
  470. /* the following two declarations are nasty.  They are also the
  471.  * easient way to solve a problem using qsort().  In the Jarvis
  472.  * routine, the vertices are sorted by polar angle wrto the centroid
  473.  * as origin.  However, I want to sort an array of indices to the
  474.  * data rather than the data itself (for efficiency, etc.)  Since I need
  475.  * access to the data by name, and the data is an instance variable, I
  476.  * need to pass self to the plain-C routines and get the actual data by
  477.  * following self.
  478.  */
  479. static float mx,my; /* used in xcompar and doJarvisHull */
  480. static TwoDView *myself;
  481.  
  482. #define XX(i) myself->data[i*2]
  483. #define YY(i) myself->data[i*2+1]
  484.  
  485. int xcompar(int *pp1,int *pp2) /*used in Graham scan to sort pts by polar angle*/
  486. {
  487.   int p1,p2,q1,q2;
  488.   float x1,x2,y1,y2,a;
  489.   p1= *pp1; p2= *pp2;
  490.   x1= XX(p1)-mx; y1= YY(p1)-my;
  491.   x2= XX(p2)-mx; y2= YY(p2)-my;
  492.   /* cute li'l optimization.  If we can sort by quadrant, do it. */
  493.   q1=QUAD(x1,y1); q2=QUAD(x2,y2);
  494.   if (q1<q2)  return(-1);
  495.   if (q2<q1)  return(1);
  496.   /* if we get here, p1 & p2 are in same quadrant. shucks. */
  497.   a=SIGNEDAREA(0.0,0.0,x2,y2,x1,y1);
  498.   if (a<0.0) return(-1);
  499.   if (a==0.0) return(0);
  500.   return(1);
  501. }
  502.  
  503. /* be safe. */
  504. #undef XX
  505. #undef YY
  506.  
  507. - doGrahamHull
  508. {
  509.   /* Graham's scan for planar convex hull. From Preparata and Shamos */
  510.   int i,mindex=0,start,prev,current,next,nnext;
  511.   int t1,t2,t3;
  512.   float a,minx,xx;
  513.   int *pointers;
  514.   int nh;
  515.  
  516.   NXSetColor([highColorWell color]);
  517.  
  518.   /* THIS IS GROSS. */
  519.   myself = self;
  520.  
  521.   NX_MALLOC(pointers,int,numPoints);
  522.   nh=numPoints;
  523.   /* find point in hull interior (centroid will do)*/
  524.   STATUS("finding interior point");
  525.   mx=0.0; my=0.0; minx=999;
  526.   for(i=0;i<numPoints;i++) {
  527.     mx += X(i);
  528.     my += Y(i);
  529.     };
  530.   mx /= numPoints;
  531.   my /= numPoints;
  532.  
  533.   for(i=0;i<numPoints;i++) {
  534.     xx= X(i);
  535.     if (xx<minx) { minx=xx; mindex=i;};
  536.     };
  537.  
  538.   STATUS("sorting points by polar angle");
  539.   /* sort points by polar angle and distance */
  540.   for(i=0;i<numPoints;i++)  pointers[i]=i;
  541.   qsort((void *)pointers,(size_t)numPoints,sizeof(int),xcompar);
  542.  
  543.   /* find min-X vertex (guaranteed to be on CH) */
  544.   for(i=0;i<numPoints;i++) if (pointers[i]==mindex) break;
  545.  
  546.   start=current=i; /* point i is a hull vertex. */
  547.  
  548.   /* set up pointers in linked list */
  549.   prev=(current==0)?nh-1:current-1;
  550.   next=(current==nh-1)?0:current+1;
  551.   nnext=(next==nh-1)?0:next+1;
  552.   /* loop over all points */
  553.   STATUS("Performing Graham's scan");
  554.   while(pointers[next]!=pointers[start]) {
  555.     if (nh==3) break; /* triangle is ALWAYS a convex polygon */
  556.     t1= pointers[current]; t2= pointers[next]; t3= pointers[nnext];
  557.     NI;
  558.     [self drawEdge:X(current):Y(current):X(next):Y(next)];
  559.     [self drawEdge:X(current):Y(current):X(nnext):Y(nnext)];
  560.     [self drawEdge:X(nnext):Y(nnext):X(next):Y(next)];
  561.     NXPing();
  562.     a=SIGNEDAREA(X(t1),Y(t1),X(t2),Y(t2),X(t3),Y(t3));
  563.     if (a<0.0) { /* delete next vertex */
  564.       for(i=next+1;i<nh;i++) pointers[i-1]= pointers[i];
  565.       nh--;
  566.       if (start>=next) start--;
  567.       if (current>=next) current--;
  568.       if (current != start) {
  569.         /* back up one vertex in list */
  570.         current --;
  571.         if (current<0) current += nh;
  572.         prev=(current==0)?nh-1:current-1;
  573.         next=(current==nh-1)?0:current+1;
  574.         nnext=(next==nh-1)?0:next+1;
  575.         }
  576.       else { /* do not back up if current vertex is starting vertex. */
  577.         prev=(current==0)?nh-1:current-1;
  578.         next=(current==nh-1)?0:current+1;
  579.         nnext=(next==nh-1)?0:next+1;
  580.         };
  581.       }
  582.     else { /* move forward in linked list */
  583.       prev=current;
  584.       current=next;
  585.       next=(next==nh-1)?0:next+1;
  586.       nnext=(next==nh-1)?0:next+1;
  587.       };
  588.     };
  589.   for(i=0;i<nh;i++) ch_vertex[i]=pointers[i];
  590.   nch_vertices=nh;
  591.   NX_FREE(pointers);
  592.   chExists=YES;
  593.   return self;
  594. }
  595.  
  596. - doPrimMST
  597. {
  598.   /* Prim's quadratic MST algorithm - from Horowitz & Sahni */
  599.   int *near;
  600.   int i,j=0,k=0,l=0;
  601.   float mincost,x,xmin;
  602.  
  603. #ifdef DEBUG
  604.     MESSAGE("doPrimMST");
  605. #endif
  606.  
  607.   NX_MALLOC(near,int,numPoints);
  608.   bzero(near,numPoints*sizeof(int));
  609.   mincost=10000000000.0;
  610.   /* find shortest edge (O(n^2 time)) */
  611.   STATUS("finding shortest edge");
  612.   for(i=0;i<numPoints-1;i++) {
  613.    char buf[80];
  614.    sprintf(buf,"point %d",i);
  615.    STATUS(buf);
  616.    for(j=i+1;j<numPoints;j++) {
  617.      x=cost(XY(i),XY(j));
  618.      NI;
  619.      [self drawEdge:X(i):Y(i):X(j):Y(j)];
  620.      NXPing();
  621.      if (x<mincost) { mincost=x; k=i; l=j; };
  622.      };
  623.    };
  624.   /* (k,l) is the first edge in the MST */
  625.   mst_edge[0]=k; mst_edge[1]=l;
  626.   NI;
  627.   [self drawEdge:X(k):Y(k):X(l):Y(l)];
  628.   /* set up initial nearest-neighbor array for k and l */
  629.   for(i=0;i<numPoints;i++)
  630.     if (cost(XY(i),XY(l))<cost(XY(i),XY(k)))
  631.       near[i]=l;
  632.     else
  633.       near[i]=k;
  634.   near[k]= near[l]= -1;
  635.   /* add the remaining n-2 edges */
  636.   for(i=1;i<numPoints-1;i++) {
  637.     char buf[80];
  638.     sprintf(buf,"adding edge %d",i);
  639.     STATUS(buf);
  640.     xmin=100000000000.0;
  641.     for(k=0;k<numPoints;k++) 
  642.       if (near[k]!= -1) {
  643.         x=cost(XY(k),XY(near[k]));
  644.         if (x<xmin) { xmin=x; j=k;};
  645.         };
  646.     mst_edge[i*2] = j; mst_edge[i*2+1]= near[j];
  647.     NI;
  648.     [self drawEdge:X(j):Y(j):X(near[j]):Y(near[j])];
  649.     mincost += xmin;
  650.     near[j]= -1;
  651.     for(k=0;k<numPoints;k++)
  652.       if (near[k]!= -1)
  653.         if (cost(XY(k),XY(near[k])) > cost(XY(k),XY(j)))
  654.           near[k]=j;
  655.     };
  656.   NX_FREE(near);
  657.   NXPing();
  658.   mstExists=YES;
  659.   STATUS("idle");
  660.   return self;
  661. }
  662.  
  663. - erase
  664. {
  665.   NXRect r;
  666.   [[self getBounds:&r] lockFocus];
  667.   NXSetColor([bgColorWell color]);
  668.   NXRectFill(&r);
  669.   [self unlockFocus];
  670.   return self;
  671. }
  672.  
  673. - drawDT  /* focus must already be locked */
  674. {
  675.   int i;
  676.   for(i=0;i<ndt_edge;i++) {
  677.     int i1=dt_edge[i*2],i2=dt_edge[i*2+1];
  678.     char buf[80];
  679.     sprintf(buf,"DT edge %d",i);
  680.     STATUS(buf);
  681.     [self drawEdge:X(i1):Y(i1):X(i2):Y(i2)];
  682.     };
  683.   return self;
  684. }
  685.  
  686. - drawGG  /* focus must already be locked */
  687. {
  688.   int i;
  689.   for(i=0;i<ngg_edge;i++) {
  690.     int i1=gg_edge[i*2],i2=gg_edge[i*2+1];
  691.     char buf[80];
  692.     sprintf(buf,"GG edge %d",i);
  693.     STATUS(buf);
  694.     [self drawEdge:X(i1):Y(i1):X(i2):Y(i2)];
  695.     };
  696.   return self;
  697. }
  698.  
  699. - drawRNG  /* focus must already be locked */
  700. {
  701.   int i;
  702.   for(i=0;i<nrng_edge;i++) {
  703.     int i1=rng_edge[i*2],i2=rng_edge[i*2+1];
  704.     char buf[80];
  705.     sprintf(buf,"RNG edge %d",i);
  706.     STATUS(buf);
  707.     [self drawEdge:X(i1):Y(i1):X(i2):Y(i2)];
  708.     };
  709.   return self;
  710. }
  711.  
  712. /*--------------------------------------------------------------------
  713. This function does the actual drawing for the algorithms. Most of the 
  714. routines merely draw line between sets of vertices.
  715.  
  716.                                                  Bill Roth/1991-Nov-17
  717. --------------------------------------------------------------------*/
  718. - drawSelf:(NXRect *)rects:(int)rectCount
  719. {
  720.   int i;
  721. #ifdef DEBUG
  722.   fprintf(stderr,"drawSelf (%d points)\n",numPoints);
  723. #endif
  724.  
  725.   STATUS("redisplaying");
  726.   NXSetColor([bgColorWell color]);
  727.   NXRectFill(&rects[0]); //fill page with current color.
  728.  
  729.   setUpScaling(self); // set up scaling
  730.  
  731.   setUpDrawing(self);
  732.   NXSetColor([self->fgColorWell color]);
  733.   for(i=0;i<numPoints;i++) {
  734. #ifdef PRINTLOTS
  735.     fprintf(stderr,"%d: %f %f\n",i,X(i),Y(i));
  736. #endif
  737.     PSnewpath();
  738.     PSarc(X(i),Y(i),width,0.0,360.0);
  739.     PSfill();
  740.     };
  741.   NXPing();
  742.  
  743.   /* draw selected data structure */
  744.   if (displayFlag != DISP_PTS_ONLY) {
  745. #ifdef DEBUG
  746.     MESSAGE("drawing everything");
  747. #endif
  748.  
  749.     switch(operation) {
  750.       case OP_PRIM_MST:
  751.       case OP_KRUSKAL_MST: if (mstExists) {
  752.         for(i=0;i<numPoints-1;i++) {
  753.           int i1=mst_edge[i*2], i2=mst_edge[i*2+1];
  754.           PSnewpath();
  755.           PSmoveto(X(i1),Y(i1));
  756.           PSlineto(X(i2),Y(i2));
  757.           PSstroke();
  758.           NXPing();
  759.           };
  760.         break;
  761.         };
  762.       case OP_JARVIS_HULL:
  763.       case OP_GRAHAM_HULL: if (chExists) {
  764.         PSnewpath();
  765.         PSmoveto(X(ch_vertex[0]),Y(ch_vertex[0]));
  766.         for(i=1;i<nch_vertices;i++) PSlineto(X(ch_vertex[i]),Y(ch_vertex[i]));
  767.         PSclosepath();
  768.         PSstroke();
  769.         NXPing();
  770.         break;
  771.         };
  772.       case OP_VORONOI_DIAGRAM: if (vorExists) {
  773.         float *foo;
  774.         NX_MALLOC(foo,float,numPoints*2);
  775.         for(i=0;i<numPoints;i++) {
  776.           int nv,j;
  777.           if ((nv=find_vregion(i,foo)) == -1) {
  778.             NXRunAlertPanel("Voronoi","find_vregion (%d) failed",
  779.                             NULL,NULL,NULL,i);
  780.             break;
  781.             };
  782.           PSnewpath();
  783.           PSmoveto(foo[0],foo[1]);
  784.           for(j=1;j<nv;j++) PSlineto(foo[j*2],foo[j*2+1]);
  785.           PSclosepath();
  786.           PSstroke();
  787.           NXPing();
  788.           };
  789.         NX_FREE(foo);
  790.         break;
  791.         };
  792.       case OP_DELAUNAY_TRIANGULATION: if (vorExists) [self drawDT]; break;
  793.       case OP_GABRIEL_GRAPH: if (ggExists)  [self drawGG]; break;
  794.       case OP_RELATIVE_NEIGHBORHOOD_GRAPH: if (rngExists) [self drawRNG]; break;
  795.       case OP_TSP_STUPID_NEIGHBOR:
  796.       case OP_TSP_NEAREST_NEIGHBOR: 
  797.       case OP_TSP_CHEAPEST_INSERTION:
  798.       case OP_TSP_NEAREST_ADDITION:
  799.       case OP_TSP_FARTHEST_INSERTION:
  800.      [self drawTSP]; break;
  801.       };
  802.     };
  803.   NXPing();
  804.   STATUS("idle");
  805.   return self;
  806. }
  807.  
  808. /* draw an edge with given endpoints */
  809. -drawEdge:(float)x1:(float)y1:(float)x2:(float)y2
  810. { /*assumes focus is locked already and attributes (color, width) already set*/
  811.   PSnewpath();
  812.   PSmoveto(x1,y1);
  813.   PSlineto(x2,y2);
  814.   PSstroke();
  815.   return self;
  816. }
  817.  
  818. - doVoronoiDiagram
  819. {
  820.   NXRect r;
  821.   float xmin,xmax,ymin,ymax;
  822.  
  823.   STATUS("Finding Voronoi diagram");
  824.   [self getBounds:&r];
  825.   xmin=-1.01;
  826.   xmax=1.01;
  827.   ymin=-1.01;
  828.   ymax=1.01;
  829.  
  830.   if (load_vsites(numPoints,data,xmin,ymin,xmax,ymax)) {
  831.     NXRunAlertPanel("Voronoi","load_vsites failed",NULL,NULL,NULL);
  832.     vorExists=NO;
  833.     return self;
  834.     };
  835.   vorExists=YES;
  836.   return self;
  837. }
  838.  
  839. static void checkedge(TwoDView *s,int i1,int i2)
  840. {
  841.   int i;
  842.   int ii1=MIN(i1,i2),ii2=MAX(i1,i2);
  843.   for(i=0;i<s->ndt_edge;i++)
  844.     if ((s->dt_edge[i*2]==ii1)&&(s->dt_edge[i*2+1]==ii2)) return;
  845.   s->dt_edge[s->ndt_edge*2]=ii1;
  846.   s->dt_edge[s->ndt_edge*2+1]=ii2;
  847.   s->ndt_edge++;
  848. }
  849.  
  850. - doDelaunayTriangulation
  851. {
  852.   int ndt,i;
  853.   TRI *tris;
  854.   [self doVoronoiDiagram]; /* cheat! */
  855.  
  856.   STATUS("building Delaunay triangulation data structures");
  857.   /* from list of triangles, obtain minimal list of edged (toss dups) */
  858.   if ((ndt=find_dtriangles(&tris)) == -1) {
  859.     NXRunAlertPanel("Delaunay","find_dtriangles() failed",
  860.                     NULL,NULL,NULL);
  861.     return self;
  862.     };
  863.  
  864.   NX_MALLOC(dt_edge,int,2*3*ndt);
  865.   ndt_edge=0;
  866.  
  867.   for(i=0;i<ndt;i++) {
  868.     int p1=tris[i].v1->pid;
  869.     int p2=tris[i].v2->pid;
  870.     int p3=tris[i].v3->pid;
  871.     checkedge(self,p1,p2);
  872.     checkedge(self,p1,p3);
  873.     checkedge(self,p2,p3);
  874.     };
  875.   dtExists=YES;
  876. #ifdef PRINTLOTS
  877.   for(i=0;i<ndt_edge;i++)
  878.     fprintf(stderr,"%d: %d %d\n",i,dt_edge[i*2],dt_edge[i*2+1]);
  879. #endif
  880.   return self;
  881. }
  882.  
  883.  
  884. - doGabrielGraph
  885. {
  886.   int i;
  887.  
  888.   if (!dtExists)[self doDelaunayTriangulation];
  889.   /* we need to see the Delaunay graph while we're animating */
  890.   NXSetColor([fgColorWell color]);
  891.   PSsetinstance(NO);
  892.   [[[self drawDT] window] flushWindow];
  893.   NXSetColor([highColorWell color]);
  894.   PSsetinstance(YES);
  895.  
  896.   ngg_edge=ndt_edge;
  897.   NX_MALLOC(gg_edge,int,2*ngg_edge);
  898.  
  899.   bcopy(dt_edge,gg_edge,2*ngg_edge*sizeof(int));
  900.  
  901.  
  902.   /*for each DT edge, check circle of influence */
  903.   for(i=0;i<ngg_edge;i++) {
  904.     int i1=gg_edge[i*2], i2=gg_edge[i*2+1];
  905.     int j;
  906.     float x1=X(i1),y1=Y(i1);
  907.     float x2=X(i2),y2=Y(i2);
  908.     float cx=(x1+x2)/2,cy=(y1+y2)/2,r=0.5*sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
  909.     char buf[80];
  910. #ifdef PRINTLOTS
  911.     fprintf(stderr,"edge %d (%d %d)\n",i,i1,i2);
  912.     fprintf(stderr,"(%f %f) -> (%f %f)\n",x1,y2,x2,y2);
  913.     fprintf(stderr,"center %f %f rad %f\n",cx,cy,r);
  914. #endif
  915.     sprintf(buf,"considering Delaunay edge %d",i);
  916.     STATUS(buf);
  917.     NI;
  918.     PSnewpath();
  919.     PSarc(cx,cy,r,0.0,360.0);
  920.     PSstroke();
  921.     NXPing();
  922.  
  923.     /* check to see if any other vertex in within the circle of influence.
  924.        if so, remove the edge from the GG */
  925.     for(j=0;j<numPoints;j++) {
  926.       if ((j!=i1)&&(j!=i2)) {
  927.         float x=X(j),y=Y(j),d=(x-cx)*(x-cx)+(y-cy)*(y-cy)-r*r;
  928. #ifdef PRINTLOTS
  929.         fprintf(stderr,"checking %d (%f %f) d %g\n",j,x,y,d);
  930. #endif
  931.         if (d<0.0) { /* clobber edge */
  932.           int k;
  933. #ifdef DEBUG
  934.           fprintf(stderr,"die.\n");
  935. #endif
  936.           for(k=i;k<ngg_edge-1;k++) {
  937.             gg_edge[k*2]=gg_edge[(k+1)*2];
  938.             gg_edge[k*2+1]=gg_edge[(k+1)*2+1];
  939.             };
  940.           ngg_edge--;
  941.           /* highlight the dead edge */
  942.           PSsetinstance(NO);
  943.           PSnewpath();
  944.           PSmoveto(x1,y1);
  945.           PSlineto(x2,y2);
  946.           PSstroke();
  947.           PSsetinstance(YES);
  948.           i--;
  949.           break;
  950.           };
  951.         };
  952.       };
  953.     };
  954.   NX_REALLOC(gg_edge,int,2*ngg_edge);
  955.   ggExists=YES;
  956.   return self;
  957. }
  958.  
  959. - doRelativeNeighborhoodGraph
  960. {
  961.   int i;
  962.  
  963.   if (!dtExists)[self doDelaunayTriangulation];
  964.   /* we need to see the Delaunay graph while we're animating */
  965.   PSsetinstance(NO);
  966.   NXSetColor([fgColorWell color]);
  967.   [[[self drawDT] window] flushWindow];
  968.   NXSetColor([highColorWell color]);
  969.   PSsetinstance(YES);
  970.  
  971.   nrng_edge=ndt_edge;
  972.   NX_MALLOC(rng_edge,int,2*nrng_edge);
  973.  
  974.   bcopy(dt_edge,rng_edge,2*nrng_edge*sizeof(int));
  975.  
  976.  
  977.   /*for each DT edge, check lune of influence */
  978.   for(i=0;i<nrng_edge;i++) {
  979.     int i1=rng_edge[i*2], i2=rng_edge[i*2+1];
  980.     int j;
  981.     float x1=X(i1),y1=Y(i1);
  982.     float x2=X(i2),y2=Y(i2);
  983.     float r2=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
  984.     float r=sqrt(r2);
  985.     char buf[80];
  986. #ifdef PRINTLOTS
  987.     fprintf(stderr,"edge %d (%d %d)\n",i,i1,i2);
  988.     fprintf(stderr,"(%f %f) -> (%f %f)\n",x1,y2,x2,y2);
  989.     fprintf(stderr,"rad^2 %f\n",r2);
  990. #endif
  991.     sprintf(buf,"considering Delaunay edge %d",i);
  992.     STATUS(buf);
  993.     NI;
  994.     PSnewpath();
  995.     PSarc(x1,y1,r,0.0,360.0);
  996.     PSmoveto(x2,y2); /* eliminate annoying connector */
  997.     PSarc(x2,y2,r,0.0,360.0);
  998.     PSstroke();
  999.     NXPing();
  1000.  
  1001.     /* check to see if any other vertex in within the lune of influence.
  1002.        if so, remove the edge from the RNG */
  1003.     for(j=0;j<numPoints;j++) {
  1004.       if ((j!=i1)&&(j!=i2)) {
  1005.         float x=X(j),y=Y(j);
  1006.         float d1=(x-x1)*(x-x1)+(y-y1)*(y-y1)-r*r;
  1007.         float d2=(x-x2)*(x-x2)+(y-y2)*(y-y2)-r*r;
  1008. #ifdef PRINTLOTS
  1009.         fprintf(stderr,"checking %d (%f %f) d1 %g d2 %g\n",j,x,y,d1,d2);
  1010. #endif
  1011.         if ((d1<0.0)&&(d2<0.0)) { /* clobber edge */
  1012.           int k;
  1013. #ifdef PRINTLOTS
  1014.           fprintf(stderr,"die.\n");
  1015. #endif
  1016.           for(k=i;k<nrng_edge-1;k++) {
  1017.             rng_edge[k*2]=rng_edge[(k+1)*2];
  1018.             rng_edge[k*2+1]=rng_edge[(k+1)*2+1];
  1019.             };
  1020.           nrng_edge--;
  1021.           /* highlight the dead edge */
  1022.           PSsetinstance(NO);
  1023.           PSnewpath();
  1024.           PSmoveto(x1,y1);
  1025.           PSlineto(x2,y2);
  1026.           PSstroke();
  1027.           PSsetinstance(YES);
  1028.           i--;
  1029.           break;
  1030.           };
  1031.         };
  1032.       };
  1033.     };
  1034.   NX_REALLOC(rng_edge,int,2*nrng_edge);
  1035.   rngExists=YES;
  1036.   return self;
  1037. }
  1038.  
  1039. - saveTIFF:sender
  1040. {
  1041.   NXRect r;
  1042.   id bm=[NXBitmapImageRep alloc];
  1043.   id sp=[SavePanel new];
  1044.   NXStream *stream;
  1045.   int fd;
  1046.  
  1047.   [self lockFocus];
  1048.   [self getBounds:&r];
  1049.   [bm initData:NULL fromRect:&r];
  1050.   [self unlockFocus];
  1051.   
  1052.   [sp setRequiredFileType:"tiff"];
  1053.   if (![sp runModal]) return self;
  1054.   fd=open([sp filename],O_CREAT|O_RDWR,0644);
  1055.   /*[sp free]; screaming death! screaming death! don't do this! */
  1056.   stream = NXOpenFile(fd,NX_READWRITE);
  1057.   if (!stream) {
  1058.     NXRunAlertPanel("TIFF","NXOpenFile failed",NULL,NULL,NULL);
  1059.     perror("NXOpenFile");
  1060.     [bm free];
  1061.     close(fd);
  1062.     return self;
  1063.     };
  1064.   STATUS("saving image as TIFF");
  1065.   [bm writeTIFF:stream usingCompression:NX_TIFF_COMPRESSION_LZW];
  1066.   [bm free];
  1067.   NXClose(stream);
  1068.   close(fd);
  1069.   STATUS("idle");
  1070.   return self;
  1071. }
  1072.  
  1073. - saveData:sender
  1074. {
  1075.   id sp=[SavePanel new];
  1076.   FILE *fp;
  1077.   int i;
  1078.  
  1079.   [sp setRequiredFileType:"2Ddata"];
  1080.   if (![sp runModal]) return self;
  1081.   fp=fopen([sp filename],"w");
  1082.   /*[sp free];*/
  1083.   if (!fp) {
  1084.     NXRunAlertPanel("Data","Couldn't open file",NULL,NULL,NULL);
  1085.     return self;
  1086.     };
  1087.   STATUS("saving data");
  1088.   fprintf(fp,"%d\n",numPoints);
  1089.   for(i=0;i<numPoints;i++) fprintf(fp,"%g %g\n",X(i),Y(i));
  1090.   fclose(fp);
  1091.   STATUS("idle");
  1092.   return self;
  1093. }
  1094.  
  1095. - openData:sender
  1096. {
  1097.   id op=[OpenPanel new];
  1098.   const char *const types[] = { "2Ddata" , NULL};
  1099.   FILE *fp;
  1100.   int i;
  1101.  
  1102.   [op setRequiredFileType:"2Ddata"];
  1103.   [op runModalForDirectory:"." file:"" types:types];
  1104.   chdir([op directory]);
  1105.   if (![op filenames]) {
  1106.     /*[op free];*/
  1107.     return self;
  1108.     };
  1109.  
  1110.   fp=fopen(*[op filenames],"r");
  1111.   /*[op free];*/
  1112.   if (!fp) {
  1113.     NXRunAlertPanel("Open","Couldn't open file",NULL,NULL,NULL);
  1114.     return self;
  1115.     };
  1116.  
  1117.   STATUS("reading data");
  1118.   fscanf(fp,"%d ",&numPoints);
  1119.   initGeometryStuff(self,numPoints);
  1120.   for(i=0;i<numPoints;i++) {
  1121.     fscanf(fp,"%f %f ",&X(i),&Y(i));
  1122.     };
  1123.   fclose(fp);
  1124.   [self disp:0];
  1125.   STATUS("idle");
  1126.   return self;
  1127. }
  1128.  
  1129. - close:sender
  1130. {
  1131.   initGeometryStuff(self,0);
  1132.   [self erase];
  1133.   return self;
  1134. }
  1135.   
  1136. -lineWidthChanged:sender
  1137. {
  1138.   char buf[80];
  1139.   sprintf(buf,"Line width: %6.3f\n",[sender floatValue]);
  1140.   [lineWidthText setStringValue:buf];
  1141.   /* could redraw self here */
  1142.   if (autoUpdate) [self display];
  1143.   return self;
  1144. }
  1145.  
  1146.  
  1147. -setFgColorWell:sender
  1148. {
  1149.   fgColorWell = sender;
  1150.   [sender setColor:NXConvertGrayToColor(0.0)];
  1151.   return self;
  1152. }
  1153.  
  1154. -setBgColorWell:sender
  1155. {
  1156.   bgColorWell = sender;
  1157.   [sender setColor:NXConvertGrayToColor(1.0)];
  1158.   return self;
  1159. }
  1160.  
  1161.  
  1162. -setHighColorWell:sender
  1163. {
  1164.   highColorWell = sender;
  1165.   [sender setColor:NXConvertGrayToColor(0.666)];
  1166.   return self;
  1167. }
  1168.  
  1169. - (BOOL)acceptsFirstResponder { return YES; }
  1170. - (BOOL)acceptsFirstMouse { return YES; }
  1171.  
  1172. - copy:sender
  1173. {
  1174.   id pb=[Pasteboard new];
  1175.   NXStream *stream;
  1176.   char *d;
  1177.   int length,maxLength;
  1178.  
  1179.   STATUS("copying image to clipboard");
  1180.   [pb declareTypes:&NXPostScriptPboard num:1 owner:self];
  1181.   stream=NXOpenMemory(NULL,0,NX_WRITEONLY);
  1182.   [self copyPSCodeInside:NULL to:stream];
  1183.   NXGetMemoryBuffer(stream,&d,&length,&maxLength);
  1184.   [pb writeType:NXPostScriptPboard data:d length:length];
  1185.   NXCloseMemory(stream,NX_FREEBUFFER);
  1186.   [pb free];
  1187.   STATUS("idle");
  1188.   return self;
  1189. }
  1190.  
  1191. - saveEPS:sender
  1192. {
  1193.   NXStream *stream;
  1194.   id sp = [SavePanel new];
  1195.   int fd;
  1196.  
  1197.   [sp setRequiredFileType:"eps"];
  1198.   if (![sp runModal]) return self;
  1199.   fprintf(stderr,"filename %s\n",[sp filename]);
  1200.   fd=open([sp filename],O_CREAT|O_WRONLY,0644);
  1201.   /*[sp free];*/
  1202.   stream = NXOpenFile(fd,NX_WRITEONLY);
  1203.   if (!stream) {
  1204.     NXRunAlertPanel("EPS","NXOpenFile failed",NULL,NULL,NULL);
  1205.     perror("NXOpenFile");
  1206.     return self;
  1207.     };
  1208.   STATUS("saving image as EPS");
  1209.   [self copyPSCodeInside:NULL to:stream];
  1210.   NXClose(stream);
  1211.   close(fd);
  1212.   STATUS("idle");
  1213.   return self;
  1214. }
  1215. /*--------------------------------------------------------------------
  1216. Message from App object.
  1217.  
  1218.                                                  Bill Roth/1991-Dec-01
  1219. --------------------------------------------------------------------*/
  1220.  
  1221. - appDidInit: sender;
  1222. {
  1223.     drawTime = [timeSlider intValue];
  1224.     [timeField setIntValue: drawTime at: 0];
  1225.     [timeField setEnabled: NO]; // agree with NIB
  1226.     [timeSlider setEnabled: NO];// agree with NIB
  1227.     return self ;
  1228. }
  1229. - doOptimize :sender
  1230. {
  1231.     [self Optimize];
  1232.     return self;
  1233. }
  1234. @end
  1235.